{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对应`tf.kears` 版本的03，在训练过程中加入更多的控制\n",
    "\n",
    "1. 训练中保存/保存最好的模型\n",
    "2. 早停 \n",
    "3. 训练过程可视化\n",
    "\n",
    "<font color=\"red\">注</font>: 使用 tensorboard 可视化需要安装 tensorflow (TensorBoard依赖于tensorflow库，可以任意安装tensorflow的gpu/cpu版本)\n",
    "\n",
    "```shell\n",
    "pip install tensorflow\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:54:54.033391Z",
     "start_time": "2025-03-06T07:54:54.022583Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)  #设备是cuda:0，即GPU，如果没有GPU则是cpu\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=9, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.1\n",
      "numpy 2.0.1\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.1\n",
      "torch 2.6.0+cu126\n",
      "cuda:0\n"
     ]
    }
   ],
   "execution_count": 25
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据准备"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:54:54.221954Z",
     "start_time": "2025-03-06T07:54:54.174580Z"
    }
   },
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "# fashion_mnist图像分类数据集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# torchvision 数据集里没有提供训练集和验证集的划分\n",
    "# 当然也可以用 torch.utils.data.Dataset 实现人为划分"
   ],
   "outputs": [],
   "execution_count": 26
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:54:54.231362Z",
     "start_time": "2025-03-06T07:54:54.224455Z"
    }
   },
   "cell_type": "code",
   "source": "type(train_ds)",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torchvision.datasets.mnist.FashionMNIST"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 27
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:54:54.241247Z",
     "start_time": "2025-03-06T07:54:54.233354Z"
    }
   },
   "source": [
    "# 从数据集到dataloader\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=32, shuffle=True)\n",
    "val_loader = torch.utils.data.DataLoader(test_ds, batch_size=32, shuffle=False)"
   ],
   "outputs": [],
   "execution_count": 28
  },
  {
   "cell_type": "code",
   "source": [
    "# 查看数据\n",
    "for datas, labels in train_loader:\n",
    "    print(datas.shape)\n",
    "    print(labels.shape)\n",
    "    break\n",
    "#查看val_loader\n",
    "for datas, labels in val_loader:\n",
    "    print(datas.shape)\n",
    "    print(labels.shape)\n",
    "    break"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-06T07:54:54.294938Z",
     "start_time": "2025-03-06T07:54:54.271156Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([32, 1, 28, 28])\n",
      "torch.Size([32])\n",
      "torch.Size([32, 1, 28, 28])\n",
      "torch.Size([32])\n"
     ]
    }
   ],
   "execution_count": 29
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 定义模型"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:54:54.328960Z",
     "start_time": "2025-03-06T07:54:54.319867Z"
    }
   },
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28 * 28, 300),  # in_features=784, out_features=300\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(300, 100),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(100, 10),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        # x.shape [batch size, 1, 28, 28]\n",
    "        x = self.flatten(x)  \n",
    "        # 展平后 x.shape [batch size, 28 * 28]\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        # logits.shape [batch size, 10]\n",
    "        return logits\n",
    "    \n",
    "model = NeuralNetwork()"
   ],
   "outputs": [],
   "execution_count": 30
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练\n",
    "\n",
    "pytorch的训练需要自行实现，包括\n",
    "1. 定义损失函数\n",
    "2. 定义优化器\n",
    "3. 定义训练步\n",
    "4. 训练"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:54:54.384322Z",
     "start_time": "2025-03-06T07:54:54.375834Z"
    }
   },
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        #datas.shape [batch size, 1, 28, 28]\n",
    "        #labels.shape [batch size]\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item()) # tensor.item() 获取tensor的数值，loss是只有一个元素的tensor\n",
    "        \n",
    "        preds = logits.argmax(axis=-1)    # 验证集预测, axis=-1 表示最后一个维度,因为logits.shape [batch size, 10]，所以axis=-1表示对最后一个维度求argmax，即对每个样本的10个类别的概率求argmax，得到最大概率的类别, preds.shape [batch size]\n",
    "        pred_list.extend(preds.cpu().numpy().tolist()) # tensor转numpy，再转list\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list) # 验证集准确率\n",
    "    return np.mean(loss_list), acc # 返回验证集平均损失和准确率\n"
   ],
   "outputs": [],
   "execution_count": 31
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TensorBoard 可视化\n",
    "\n",
    "pip install tensorboard\n",
    "训练过程中可以使用如下命令启动tensorboard服务。注意使用绝对路径，否则会报错\n",
    "\n",
    "```shell\n",
    " tensorboard  --logdir=\"D:\\PycharmProjects\\pythondl\\chapter_2_torch\\runs\" --host 0.0.0.0 --port 8848\n",
    "```"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "在命令行where tensorboard才可以用"
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:54:54.437589Z",
     "start_time": "2025-03-06T07:54:54.427205Z"
    }
   },
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs) # 实例化SummaryWriter, log_dir是log存放路径，flush_secs是每隔多少秒写入磁盘\n",
    "\n",
    "    def draw_model(self, model, input_shape):#graphs\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape)) # 画模型图\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            ) # 画loss曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        ) # 画acc曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "        ) # 画lr曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss,把loss，val_loss取掉，画loss曲线\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss) # 画loss曲线\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc) # 画acc曲线\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate) # 画lr曲线\n"
   ],
   "outputs": [],
   "execution_count": 32
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save Best\n"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:54:54.477137Z",
     "start_time": "2025-03-06T07:54:54.465513Z"
    }
   },
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=500, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir # 保存路径\n",
    "        self.save_step = save_step # 保存步数\n",
    "        self.save_best_only = save_best_only # 是否只保存最好的模型\n",
    "        self.best_metrics = -1 # 最好的指标，指标不可能为负数，所以初始化为-1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir): # 如果不存在保存路径，则创建\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0: #每隔save_step步保存一次\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None # 必须传入metric\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\")) # 保存最好的模型，覆盖之前的模型，不保存step，只保存state_dict，即模型参数，不保存优化器参数\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\")) # 保存每个step的模型，不覆盖之前的模型，保存step，保存state_dict，即模型参数，不保存优化器参数\n",
    "\n"
   ],
   "outputs": [],
   "execution_count": 33
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Early Stop"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:54:54.515466Z",
     "start_time": "2025-03-06T07:54:54.509047Z"
    }
   },
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "        patience就是连续多少次准确率没有提升就停止训练\n",
    "        min_delta就是最小的提升幅度，如果准确率连续patience次没有提升，则停止训练\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience # 多少个step没有提升就停止训练\n",
    "        self.min_delta = min_delta # 最小的提升幅度\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0 # 计数器，记录多少个step没有提升\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:#用准确率\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1 # 计数器加1，下面的patience判断用到\n",
    "            \n",
    "    @property #使用@property装饰器，使得 对象.early_stop可以调用，不需要()\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ],
   "outputs": [],
   "execution_count": 34
  },
  {
   "cell_type": "code",
   "source": [
    "500*32*5"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-06T07:54:54.587845Z",
     "start_time": "2025-03-06T07:54:54.581861Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "80000"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 35
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:54:54.623748Z",
     "start_time": "2025-03-06T07:54:54.610784Z"
    }
   },
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device) # 数据放到device上\n",
    "                labels = labels.to(device) # 标签放到device上\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传，计算梯度，更新参数，这里是更新模型参数\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()  # 切换到验证集模式\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train() # 切换回训练集模式\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"], # 取出当前学习率\n",
    "                            )\n",
    "                    \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc) # 保存最好的模型，覆盖之前的模型，保存step，保存state_dict,通过metric判断是否保存最好的模型\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc) # 验证集准确率不再提升，则停止训练\n",
    "                        if early_stop_callback.early_stop:# 验证集准确率不再提升，则停止训练\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict"
   ],
   "outputs": [],
   "execution_count": 36
  },
  {
   "cell_type": "code",
   "source": [
    "epoch = 100\n",
    "\n",
    "model = NeuralNetwork()\n",
    "\n",
    "# 1. 定义损失函数 采用MSE损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用SGD\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "tensorboard_callback = TensorBoardCallback(\"runs\")\n",
    "tensorboard_callback.draw_model(model, [1, 28, 28])\n",
    "# 2. save best\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints\", save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10)\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-06T07:54:54.743930Z",
     "start_time": "2025-03-06T07:54:54.650669Z"
    }
   },
   "outputs": [],
   "execution_count": 37
  },
  {
   "cell_type": "code",
   "source": [
    "list(model.parameters())[1] #可学习的模型参数"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-06T07:54:54.758609Z",
     "start_time": "2025-03-06T07:54:54.745958Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Parameter containing:\n",
       "tensor([ 2.2287e-02,  2.2306e-02,  3.4494e-02, -3.5068e-03,  1.6085e-02,\n",
       "         1.1861e-02, -9.6938e-03,  2.9629e-02,  2.5582e-02, -1.1207e-02,\n",
       "         1.0077e-02, -2.8151e-02, -1.0226e-02,  7.8360e-03, -1.9540e-03,\n",
       "         2.6426e-02, -1.4038e-02, -2.7664e-02, -2.6099e-02, -1.7707e-02,\n",
       "         2.2224e-02,  1.1107e-02, -3.4665e-02,  2.4126e-02, -2.7500e-02,\n",
       "        -1.1091e-02,  2.7029e-02,  4.9784e-03, -1.4849e-02,  9.9457e-03,\n",
       "        -1.2617e-02, -2.5250e-02, -2.7412e-02, -1.1677e-02,  3.2992e-02,\n",
       "        -2.8707e-03, -2.1319e-02,  1.6689e-03,  2.5639e-02, -1.8196e-02,\n",
       "         4.4047e-03, -1.9751e-03,  1.2301e-02, -2.5481e-02, -3.3435e-02,\n",
       "        -3.1426e-02,  1.6893e-02,  7.4723e-03, -3.3412e-02, -2.6154e-02,\n",
       "        -6.4698e-03, -1.9199e-02, -7.1888e-03, -2.0631e-02, -1.0207e-02,\n",
       "        -2.0267e-02,  2.7258e-02, -3.2158e-02,  4.4153e-03, -3.2962e-02,\n",
       "         2.9538e-02,  2.6318e-02,  1.1039e-03,  4.7930e-03,  1.4701e-02,\n",
       "        -2.8038e-02, -2.5935e-02,  5.4848e-03, -1.3122e-02, -1.7258e-02,\n",
       "         7.0159e-03, -2.4215e-02,  3.2603e-02, -1.5155e-02, -3.6742e-03,\n",
       "         2.6721e-02,  9.3205e-03, -6.3506e-03, -5.0442e-03, -2.2000e-02,\n",
       "         9.3075e-03,  1.0225e-02, -9.9230e-03, -2.7473e-02, -3.4548e-02,\n",
       "         3.5452e-02, -2.9631e-02, -2.4264e-02, -2.6999e-02,  2.1979e-02,\n",
       "        -2.6337e-02,  3.4260e-02,  2.0445e-02, -1.0930e-02, -3.1917e-02,\n",
       "        -3.0129e-02,  2.8076e-02, -2.3958e-02,  2.8717e-02, -2.5780e-02,\n",
       "         2.9207e-02, -3.2882e-02, -8.6573e-04,  2.1033e-05,  1.6727e-02,\n",
       "         3.0252e-02, -1.8271e-02,  2.0435e-02,  2.5844e-02,  7.8405e-03,\n",
       "        -4.0356e-03, -2.3718e-02,  1.8829e-02, -1.6652e-05, -2.9965e-02,\n",
       "         2.7641e-02,  1.0521e-02,  3.1298e-02, -4.3485e-03, -3.7308e-03,\n",
       "         1.3548e-03,  2.1473e-02,  1.5750e-02, -5.9045e-03, -1.3046e-02,\n",
       "        -3.4503e-03, -1.4284e-02,  2.7914e-02,  3.2071e-02,  4.6146e-03,\n",
       "        -5.2121e-03, -1.2421e-02,  5.5003e-03, -2.1730e-02, -1.4021e-02,\n",
       "        -5.3489e-03,  2.0087e-02, -5.0794e-03, -5.4295e-03, -1.7972e-02,\n",
       "        -2.3589e-03,  2.8422e-02,  1.8546e-02, -2.7062e-02, -2.3124e-02,\n",
       "        -9.5020e-03, -3.1704e-02,  1.8709e-02, -2.2093e-02, -3.5266e-02,\n",
       "         3.4627e-02, -5.0216e-03, -1.8078e-02,  1.7488e-03, -2.4017e-02,\n",
       "        -2.1114e-03, -1.6175e-03,  3.1107e-02,  3.4087e-04,  3.0817e-02,\n",
       "        -2.9969e-02, -2.8853e-03, -3.0239e-02, -1.0367e-03, -1.3054e-02,\n",
       "        -2.2517e-02,  3.3489e-02, -3.3697e-02,  2.3133e-02, -2.1893e-02,\n",
       "        -2.0566e-02,  2.0980e-02, -1.7489e-02,  2.3326e-02, -3.2368e-02,\n",
       "        -1.5941e-02, -3.4442e-03, -2.5058e-02, -2.3491e-02, -5.2082e-03,\n",
       "        -1.5829e-02,  1.7323e-02, -1.4949e-02, -4.2184e-03, -2.6588e-02,\n",
       "         1.9501e-02,  2.3508e-03, -2.4434e-02,  3.5710e-02, -3.1793e-02,\n",
       "         8.3620e-03,  9.4929e-03, -3.3321e-02, -1.4087e-02,  3.3040e-02,\n",
       "         1.3681e-02, -2.2401e-02, -1.3868e-02,  2.0526e-02,  3.0304e-02,\n",
       "         2.7474e-05,  2.0815e-02,  2.2340e-02, -3.0485e-02,  1.0837e-03,\n",
       "        -1.6092e-02, -1.5415e-02, -1.7400e-02, -7.7359e-03, -1.3416e-02,\n",
       "         3.1318e-02, -8.2540e-03,  3.1220e-02, -3.3679e-02, -1.8099e-02,\n",
       "        -2.8504e-02, -9.9957e-03,  1.3699e-03,  3.1538e-02,  2.6927e-02,\n",
       "         3.4084e-02,  3.0116e-03, -2.9682e-02, -2.5642e-04, -3.2376e-02,\n",
       "         3.4619e-02, -1.0726e-02,  5.0195e-03, -2.9909e-02,  4.3042e-03,\n",
       "        -1.3348e-03, -2.3026e-02,  3.4749e-02, -2.6872e-02,  1.9852e-02,\n",
       "         3.1508e-02,  3.1194e-03, -1.6371e-02, -2.1466e-02,  3.6051e-03,\n",
       "         3.0568e-02, -9.3665e-04,  1.9678e-03,  2.3988e-03, -2.8470e-02,\n",
       "         2.6874e-03, -3.1283e-02, -2.5555e-02, -1.5257e-02, -3.5025e-02,\n",
       "        -1.0826e-02,  2.3732e-02,  1.8262e-04, -7.4268e-03,  3.0712e-02,\n",
       "         1.0223e-02, -2.9512e-02,  2.9673e-02, -1.8224e-02, -1.2438e-02,\n",
       "        -7.2379e-03,  1.4383e-02,  6.4893e-03, -2.3429e-02, -4.7689e-03,\n",
       "         5.9201e-03,  2.7610e-02, -2.2878e-03, -2.8854e-02,  1.0102e-02,\n",
       "         2.6093e-03,  3.4471e-02, -8.1852e-03, -2.2219e-02, -3.7342e-03,\n",
       "        -5.1082e-04,  2.3937e-02,  2.8645e-02, -1.1589e-02, -2.1451e-02,\n",
       "         1.4044e-02, -2.2959e-02, -2.3387e-02, -1.8143e-02,  2.2990e-02,\n",
       "         2.1110e-02, -1.7894e-02, -1.9734e-02, -2.2838e-02, -3.4828e-03,\n",
       "         1.6464e-02, -1.2339e-02, -5.6762e-03,  1.5964e-02, -2.1814e-02,\n",
       "        -5.1610e-03, -1.0715e-02, -1.3447e-02,  2.6576e-03,  1.4471e-02],\n",
       "       requires_grad=True)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 38
  },
  {
   "cell_type": "code",
   "source": "model.state_dict().keys() #模型参数名字",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-06T07:54:54.768293Z",
     "start_time": "2025-03-06T07:54:54.760599Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "odict_keys(['linear_relu_stack.0.weight', 'linear_relu_stack.0.bias', 'linear_relu_stack.2.weight', 'linear_relu_stack.2.bias', 'linear_relu_stack.4.weight', 'linear_relu_stack.4.bias'])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 39
  },
  {
   "cell_type": "code",
   "source": [
    "model = model.to(device) # 放到device上\n",
    "record = training(\n",
    "    model,\n",
    "    train_loader,\n",
    "    val_loader,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    tensorboard_callback=tensorboard_callback,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=1000\n",
    "    )\n",
    "#没有进度条，是因为pycharm本身jupyter的问题"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-06T08:02:42.948726Z",
     "start_time": "2025-03-06T07:54:54.771280Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/187500 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "9f6aab9884114a46b30988d4a48ccb28"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 18 / global_step 35000\n"
     ]
    }
   ],
   "execution_count": 40
  },
  {
   "cell_type": "code",
   "source": [
    "#帮我写个enumerate例子\n",
    "for i, item in enumerate([\"a\", \"b\", \"c\"]):\n",
    "    print(i, item)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-06T08:02:42.955158Z",
     "start_time": "2025-03-06T08:02:42.949755Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 a\n",
      "1 b\n",
      "2 c\n"
     ]
    }
   ],
   "execution_count": 41
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:02:42.963741Z",
     "start_time": "2025-03-06T08:02:42.957129Z"
    }
   },
   "cell_type": "code",
   "source": "record[\"val\"][-5:]",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'loss': np.float64(0.36529229626583215), 'acc': 0.8719, 'step': 31000},\n",
       " {'loss': np.float64(0.36762288779305957), 'acc': 0.8676, 'step': 32000},\n",
       " {'loss': np.float64(0.35880501803974757), 'acc': 0.8731, 'step': 33000},\n",
       " {'loss': np.float64(0.36824270471121173), 'acc': 0.8654, 'step': 34000},\n",
       " {'loss': np.float64(0.35659909065063006), 'acc': 0.8721, 'step': 35000}]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 42
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:02:42.972713Z",
     "start_time": "2025-03-06T08:02:42.964734Z"
    }
   },
   "cell_type": "code",
   "source": "record[\"train\"][-5:]",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'loss': 0.3803463578224182, 'acc': 0.8125, 'step': 34996},\n",
       " {'loss': 0.2890356183052063, 'acc': 0.90625, 'step': 34997},\n",
       " {'loss': 0.2221204936504364, 'acc': 0.90625, 'step': 34998},\n",
       " {'loss': 0.3793632388114929, 'acc': 0.8125, 'step': 34999},\n",
       " {'loss': 0.2675400972366333, 'acc': 0.875, 'step': 35000}]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 43
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:02:43.316398Z",
     "start_time": "2025-03-06T08:02:42.974707Z"
    }
   },
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "    #print(train_df.head())\n",
    "    #print(val_df.head())\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns) #因为有loss和acc两个指标，所以画个子图\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5)) #fig_num个子图，figsize是子图大小\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        #index是步数，item是指标名字\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        x_data=range(0, train_df.index[-1], 5000) #每隔5000步标出一个点\n",
    "        axs[idx].set_xticks(x_data)\n",
    "        axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", x_data)) #map生成labal\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=500)  #横坐标是 steps"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 44
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 评估"
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "model = NeuralNetwork() #上线时加载模型\n",
    "model = model.to(device)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-06T08:02:43.324875Z",
     "start_time": "2025-03-06T08:02:43.317389Z"
    }
   },
   "outputs": [],
   "execution_count": 45
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:03:56.476946Z",
     "start_time": "2025-03-06T08:03:54.590224Z"
    }
   },
   "source": [
    "# dataload for evaluating\n",
    "#模型保存有两种情况，一种是模型结构和模型参数都保存，一种是只保存模型参数，这里是只保存模型参数，所以需要加上weights_only=True\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/best.ckpt\", weights_only=True,map_location=\"cpu\"))\n",
    "\n",
    "model.eval() # 切换到验证集模式（评估模式）\n",
    "loss, acc = evaluating(model, val_loader, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.3588\n",
      "accuracy: 0.8731\n"
     ]
    }
   ],
   "execution_count": 47
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:02:45.341222Z",
     "start_time": "2025-03-06T08:02:45.337363Z"
    }
   },
   "cell_type": "code",
   "source": "",
   "outputs": [],
   "execution_count": 46
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
